package com.friend.manager;

import cn.hutool.core.collection.CollectionUtil;
import com.friend.util.QuestionConverter;
import com.friend.domain.question.Question;
import com.friend.domain.question.es.QuestionES;
import com.friend.integration.elasticsearch.QuestionRepository;
import com.friend.mapper.question.QuestionMapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * ES索引管理工具类
 * 提供手动重建索引、删除索引、创建索引等功能
 */
@Component
@Slf4j
public class ElasticsearchIndexManager {

    @Autowired
    private ElasticsearchOperations elasticsearchTemplate;

    @Autowired
    private QuestionRepository questionRepository;

    @Autowired
    private QuestionMapper questionMapper;

    private static final String INDEX_NAME = "idx_question";

    /**
     * 检查索引是否存在
     */
    public boolean indexExists() {
        try {
            return elasticsearchTemplate.indexOps(QuestionES.class).exists();
        } catch (Exception e) {
            log.error("检查索引是否存在失败", e);
            return false;
        }
    }

    /**
     * 删除索引
     */
    public boolean deleteIndex() {
        try {
            if (indexExists()) {
                elasticsearchTemplate.indexOps(QuestionES.class).delete();
                log.info("索引删除成功: {}", INDEX_NAME);
                return true;
            }
            return true;
        } catch (Exception e) {
            log.error("删除索引失败: {}", INDEX_NAME, e);
            return false;
        }
    }

    /**
     * 创建索引
     */
    public boolean createIndex() {
        try {
            elasticsearchTemplate.indexOps(QuestionES.class).create();
            elasticsearchTemplate.indexOps(QuestionES.class).putMapping();
            log.info("索引创建成功: {}", INDEX_NAME);
            return true;
        } catch (Exception e) {
            log.error("创建索引失败: {}", INDEX_NAME, e);
            return false;
        }
    }

    /**
     * 重建索引（删除+创建）
     */
    public boolean recreateIndex() {
        try {
            // 1. 删除现有索引
            if (!deleteIndex()) {
                log.error("删除索引失败，停止重建");
                return false;
            }
            
            // 2. 创建新索引
            if (!createIndex()) {
                log.error("创建索引失败，停止重建");
                return false;
            }
            
            log.info("索引重建成功: {}", INDEX_NAME);
            return true;
        } catch (Exception e) {
            log.error("重建索引失败: {}", INDEX_NAME, e);
            return false;
        }
    }

    /**
     * 全量同步数据到ES
     */
    public boolean syncAllData() {
        try {
            // 1. 从数据库查询所有题目
            List<Question> questionList = questionMapper.selectList(new LambdaQueryWrapper<Question>());
            
            if (CollectionUtil.isEmpty(questionList)) {
                log.warn("数据库中没有题目数据");
                return true;
            }
            
            // 2. 转换为ES对象并批量保存 - 使用专门的转换工具
            List<QuestionES> questionESList = QuestionConverter.toQuestionESList(questionList);
            questionRepository.saveAll(questionESList);
            
            log.info("全量同步完成，共同步 {} 个题目", questionESList.size());
            return true;
            
        } catch (Exception e) {
            log.error("全量同步数据失败", e);
            return false;
        }
    }

    /**
     * 重建索引并同步数据
     */
    public boolean recreateIndexAndSyncData() {
        try {
            // 1. 重建索引
            if (!recreateIndex()) {
                log.error("重建索引失败，停止操作");
                return false;
            }
            
            // 2. 同步数据
            if (!syncAllData()) {
                log.error("同步数据失败");
                return false;
            }
            
            log.info("重建索引并同步数据完成");
            return true;
            
        } catch (Exception e) {
            log.error("重建索引并同步数据失败", e);
            return false;
        }
    }

    /**
     * 获取索引统计信息
     */
    public String getIndexStats() {
        try {
            if (!indexExists()) {
                return "索引不存在";
            }
            
            long count = questionRepository.count();
            return String.format("索引: %s, 文档数量: %d", INDEX_NAME, count);
            
        } catch (Exception e) {
            log.error("获取索引统计信息失败", e);
            return "获取统计信息失败: " + e.getMessage();
        }
    }
}
